home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / FireMan.swf / scripts / frame_1154 / PlaceObject2_276_1146 / CLIPACTIONRECORD onClipEvent(enterFrame).as next >
Text File  |  2008-09-12  |  14KB  |  577 lines
  1. onClipEvent(enterFrame){
  2.    function hitPlatforms()
  3.    {
  4.       var u;
  5.       u = suelo = sueloI = sueloD = false;
  6.       i = -9;
  7.       while(i <= 0)
  8.       {
  9.          sueloI = sueloI || mapa.hitTest(_X + i,_Y,true);
  10.          i++;
  11.       }
  12.       i = 1;
  13.       while(i <= 9)
  14.       {
  15.          sueloD = sueloD || mapa.hitTest(_X + i,_Y,true);
  16.          i++;
  17.       }
  18.       if(sueloI && wallizq() && !sueloD && !techo)
  19.       {
  20.          return undefined;
  21.       }
  22.       if(sueloD && wallder() && !sueloI && !techo)
  23.       {
  24.          return undefined;
  25.       }
  26.       suelo = sueloI || sueloD;
  27.       if(suelo)
  28.       {
  29.          falling = false;
  30.          currenthigh = 0;
  31.          techo = false;
  32.          if(s)
  33.          {
  34.             landing.start();
  35.             s = false;
  36.          }
  37.          j = -15;
  38.          while(j <= 15)
  39.          {
  40.             i = -9;
  41.             while(i <= 9)
  42.             {
  43.                if(mapa.hitTest(_X + i,_Y + j,true) && !mapa.hitTest(_X + i,_Y + j - 1,true))
  44.                {
  45.                   u = true;
  46.                   break;
  47.                }
  48.                i++;
  49.             }
  50.             if(u)
  51.             {
  52.                break;
  53.             }
  54.             j++;
  55.          }
  56.          _Y = _Y + j;
  57.          j = vertical = 0;
  58.       }
  59.       return undefined;
  60.    }
  61.    function roof()
  62.    {
  63.       var u = techo = false;
  64.       i = -3;
  65.       while(i <= 3)
  66.       {
  67.          if(mapa.hitTest(_X + i,_Y - 30,true))
  68.          {
  69.             u = techo = true;
  70.             break;
  71.          }
  72.          i++;
  73.       }
  74.       return u;
  75.    }
  76.    function gridx(a)
  77.    {
  78.       return int(a / GRIDSIZE);
  79.    }
  80.    function gridy(b)
  81.    {
  82.       if(b >= 0)
  83.       {
  84.          return int(b / GRIDSIZE);
  85.       }
  86.       return Math.floor(b / GRIDSIZE);
  87.    }
  88.    function render()
  89.    {
  90.       if(!death)
  91.       {
  92.          scrollspeed = 0;
  93.          if(this.hitTest(_root.scrollmask))
  94.          {
  95.             doscroll = true;
  96.          }
  97.          if(_root.topeizq._x >= 0 && horizontal < 0 || _root.topeder._x <= 256 && horizontal > 0)
  98.          {
  99.             doscroll = false;
  100.          }
  101.          if(doscroll)
  102.          {
  103.             _X = lastX;
  104.             scrollspeed = setSpeed();
  105.          }
  106.          lastX = _X;
  107.          lastY = _Y;
  108.          if(timerdamage == 0 && hitted && !invisible)
  109.          {
  110.             timerdamage = FLASHTIME;
  111.             timerinvisible = INVISIBLETIME;
  112.             keys = false;
  113.             _root.currentdamage += DAMAGE;
  114.             barra.gotoAndStop(_root.currentdamage + 1);
  115.             _parent.fhitted.start();
  116.             if(rising || jumping)
  117.             {
  118.                vertical = 0.5;
  119.                falling = true;
  120.             }
  121.          }
  122.          if(timerdamage > 0)
  123.          {
  124.             flashing = true;
  125.             timerdamage--;
  126.             if(_xscale < 0 && !wallder())
  127.             {
  128.                if(doscroll)
  129.                {
  130.                   scrollspeed = hforce / 2;
  131.                }
  132.                else
  133.                {
  134.                   horizontal = hforce / 2;
  135.                }
  136.             }
  137.             if(_xscale > 0 && !wallizq())
  138.             {
  139.                if(doscroll)
  140.                {
  141.                   scrollspeed = hforce / 2 * -1;
  142.                }
  143.                else
  144.                {
  145.                   horizontal = hforce / 2 * -1;
  146.                }
  147.             }
  148.          }
  149.          if(flashing && timerdamage == 0)
  150.          {
  151.             flashing = false;
  152.             keys = true;
  153.             timerinvisible = INVISIBLETIME;
  154.             invisible = true;
  155.          }
  156.          if(invisible)
  157.          {
  158.             timerinvisible--;
  159.             timerinvisible % 2 != 0 ? (_visible = false) : (_visible = true);
  160.          }
  161.          if(timerinvisible <= 0 && invisible)
  162.          {
  163.             invisible = false;
  164.             hitted = false;
  165.             _visible = true;
  166.          }
  167.          if(_root.currentdamage + 1 >= MAXDAMAGE)
  168.          {
  169.             death = true;
  170.             barra.gotoAndStop(MAXDAMAGE);
  171.             _root.fdeath.start();
  172.          }
  173.          DAMAGE = 0;
  174.          if(!shooting && abletoshoot)
  175.          {
  176.             if(Key.isDown(SHOOT) && keys)
  177.             {
  178.                justshoot = true;
  179.                abletoshoot = false;
  180.             }
  181.             else
  182.             {
  183.                justshoot = false;
  184.             }
  185.          }
  186.          if(justshoot && !shooting)
  187.          {
  188.             if(_xscale > 0)
  189.             {
  190.                shoot1._x = _X + 41;
  191.             }
  192.             else
  193.             {
  194.                shoot1._x = _X - 41;
  195.             }
  196.             if(!vertical)
  197.             {
  198.                shoot1._y = _Y - 14;
  199.             }
  200.             else
  201.             {
  202.                shoot1._y = _Y - 20;
  203.             }
  204.             shoot1._visible = true;
  205.             if(_xscale > 0)
  206.             {
  207.                shoot1.dx = Math.abs(shoot1.dx);
  208.                shoot1._xscale = Math.abs(shoot1._xscale);
  209.             }
  210.             if(_xscale < 0)
  211.             {
  212.                shoot1.dx = Math.abs(shoot1.dx) * -1;
  213.                shoot1._xscale = Math.abs(shoot1._xscale) * -1;
  214.             }
  215.             blast.start();
  216.             shooting = true;
  217.             justshoot = false;
  218.          }
  219.          if(!shooting && !abletoshoot)
  220.          {
  221.             if(!Key.isDown(SHOOT))
  222.             {
  223.                abletoshoot = true;
  224.             }
  225.          }
  226.          x = setSpeed();
  227.          if(!flashing)
  228.          {
  229.             horizontal = x;
  230.          }
  231.          if(vertical == 0 && Key.isDown(ARRIBA) && upreleased && keys)
  232.          {
  233.             vertical = vforce * -1;
  234.             horizontal += platform.dx;
  235.             platformscroll = 0;
  236.             rising = true;
  237.             upreleased = false;
  238.             salto.start();
  239.          }
  240.          if(!falling && !uprelease)
  241.          {
  242.             if(!Key.isDown(ARRIBA))
  243.             {
  244.                upreleased = true;
  245.             }
  246.          }
  247.          if(rising)
  248.          {
  249.             if(roof())
  250.             {
  251.                falling = true;
  252.                startfall = true;
  253.                rising = false;
  254.             }
  255.             if(currenthigh < MAXJUMP && Key.isDown(ARRIBA) && !upreleased && !flashing)
  256.             {
  257.                if(roof())
  258.                {
  259.                   startfall = true;
  260.                   falling = true;
  261.                   rising = false;
  262.                }
  263.                if(currenthigh < vforcei)
  264.                {
  265.                   vertical = - Math.abs(vforcei);
  266.                }
  267.                else
  268.                {
  269.                   vertical = - Math.abs(vforce);
  270.                }
  271.                currenthigh += Math.abs(vertical);
  272.             }
  273.             else
  274.             {
  275.                vertical *= gravity;
  276.                currenthigh += Math.abs(vertical);
  277.                if(Math.abs(vertical) < 1)
  278.                {
  279.                   startfall = true;
  280.                   falling = true;
  281.                   rising = false;
  282.                }
  283.             }
  284.          }
  285.          if(Key.isDown(SLIDEKEY) && !rising && !falling && keys && slidereleased)
  286.          {
  287.             if(_xscale < 0 && !wallizq())
  288.             {
  289.                slideLeft = true;
  290.                slideRight = false;
  291.             }
  292.             if(_xscale > 0 && !wallder())
  293.             {
  294.                slideLeft = false;
  295.                slideRight = true;
  296.             }
  297.             slide = slideLeft || slideRight;
  298.             slidereleased = false;
  299.          }
  300.          if(slide && slidetimer == 0)
  301.          {
  302.             slidetimer = SLIDETIME;
  303.          }
  304.          if(slide && slidetimer > 0)
  305.          {
  306.             slidetimer--;
  307.             if(slidetimer == 0 || Key.isDown(IZQ) && slideRight || Key.isDown(DER) && slideLeft || falling || wallizq() && slideLeft || wallder() && slideRight)
  308.             {
  309.                slide = slideLeft = slideRight = slidetimer = 0;
  310.             }
  311.          }
  312.          if(!Key.isDown(SLIDEKEY) && !slidereleased)
  313.          {
  314.             slidereleased = true;
  315.          }
  316.          if(falling)
  317.          {
  318.             s = true;
  319.             if(startfall)
  320.             {
  321.                vertical = Math.abs(vforcei / 2) * accel;
  322.                startfall = false;
  323.             }
  324.             else
  325.             {
  326.                vertical = Math.abs(vertical) * accel;
  327.             }
  328.             if(vertical > MAXVERTICAL)
  329.             {
  330.                vertical = MAXVERTICAL;
  331.             }
  332.             platformscroll = 0;
  333.             hitPlatforms();
  334.             if(_Y >= 245)
  335.             {
  336.                death = true;
  337.                _root.fdeath.start();
  338.             }
  339.          }
  340.          if(tornado)
  341.          {
  342.             floating = true;
  343.             playtornado = true;
  344.             vertical2 += vforce;
  345.             if(vertical2 > MAXVERTICAL)
  346.             {
  347.                vertical2 = MAXVERTICAL / 6;
  348.             }
  349.          }
  350.          else
  351.          {
  352.             playtornado = false;
  353.          }
  354.          if(floating && !rising)
  355.          {
  356.             if(tornado)
  357.             {
  358.                vertical = - vertical2;
  359.             }
  360.             else
  361.             {
  362.                vertical = -4;
  363.                floating = false;
  364.                rising = true;
  365.                vertical2 = 0;
  366.             }
  367.          }
  368.          if(playtornado && !soundtrigged)
  369.          {
  370.             _root.wind04.setVolume(100);
  371.             _root.wind04.start();
  372.             u = 100;
  373.             soundtrigged = true;
  374.          }
  375.          if(soundtrigged && !playtornado && u > 0)
  376.          {
  377.             u -= 5;
  378.             _root.wind04.setVolume(u);
  379.             if(u == 0)
  380.             {
  381.                _root.wind04.stop();
  382.                playtornado = true;
  383.                soundtrigged = false;
  384.             }
  385.          }
  386.          tornado = false;
  387.          if(_root.windx)
  388.          {
  389.             horizontal += _root.windx;
  390.          }
  391.          _Y = _Y + vertical + platform.dy;
  392.          if(horizontal < 0 && !wallizq() || horizontal > 0 && !wallder())
  393.          {
  394.             _X = _X + horizontal;
  395.          }
  396.          drawframe();
  397.          x1 = LastX - platform._x;
  398.          x2 = _X - platform._x;
  399.          if(!falling && !rising)
  400.          {
  401.             hitPlatforms();
  402.             if(!suelo)
  403.             {
  404.                vertical = 2;
  405.                falling = true;
  406.             }
  407.          }
  408.       }
  409.       else
  410.       {
  411.          drawframe();
  412.          vertical = horizontal = doscroll = scrollspeed = 0;
  413.       }
  414.    }
  415.    function wallizq()
  416.    {
  417.       var u = false;
  418.       var t = !slide ? 12 : 20;
  419.       i = -24;
  420.       while(i < -15)
  421.       {
  422.          if(mapa.hitTest(_X - t,_Y + i,true))
  423.          {
  424.             u = true;
  425.             break;
  426.          }
  427.          i++;
  428.       }
  429.       return u;
  430.    }
  431.    function wallder()
  432.    {
  433.       var u = false;
  434.       var t = !slide ? 12 : 20;
  435.       i = -24;
  436.       while(i < -15)
  437.       {
  438.          if(mapa.hitTest(_X + t,_Y + i,true))
  439.          {
  440.             u = true;
  441.             break;
  442.          }
  443.          i++;
  444.       }
  445.       return u;
  446.    }
  447.    function setSpeed()
  448.    {
  449.       if(slideLeft && !rising)
  450.       {
  451.          forward = true;
  452.          backward = false;
  453.          if(horizontal == 0)
  454.          {
  455.             return hforce * -1;
  456.          }
  457.          return hforce * -1.5;
  458.       }
  459.       if(slideRight && !rising)
  460.       {
  461.          forward = false;
  462.          backward = true;
  463.          if(horizontal == 0)
  464.          {
  465.             return hforce;
  466.          }
  467.          return hforce * 1.5;
  468.       }
  469.       if(Key.isDown(DER) && keys && !wallder())
  470.       {
  471.          forward = false;
  472.          backward = true;
  473.          if(horizontal == 0)
  474.          {
  475.             return hforcei;
  476.          }
  477.          return hforce;
  478.       }
  479.       if(Key.isDown(IZQ) && keys && !wallizq())
  480.       {
  481.          forward = true;
  482.          backward = false;
  483.          if(horizontal == 0)
  484.          {
  485.             return hforcei * -1;
  486.          }
  487.          return hforce * -1;
  488.       }
  489.       return 0;
  490.    }
  491.    function drawFrame()
  492.    {
  493.       if(victory)
  494.       {
  495.          this.gotoAndStop("victory");
  496.          return undefined;
  497.       }
  498.       if(death)
  499.       {
  500.          this.gotoAndStop("death");
  501.          return undefined;
  502.       }
  503.       if(flashing)
  504.       {
  505.          this.gotoAndStop("hitted");
  506.          return undefined;
  507.       }
  508.       if(lastX != _X)
  509.       {
  510.          !forward ? (_xscale = Math.abs(_xscale)) : (_xscale = Math.abs(_xscale) * -1);
  511.       }
  512.       if(!shooting)
  513.       {
  514.          if(lastY > _Y && rising)
  515.          {
  516.             this.gotoAndStop("jump");
  517.             _root.estado = 3;
  518.             return undefined;
  519.          }
  520.       }
  521.       else if(lastY > _Y && rising)
  522.       {
  523.          this.gotoAndStop("attackJ");
  524.          _root.estado = 4;
  525.          return undefined;
  526.       }
  527.       if(lastY < _Y && falling || floating)
  528.       {
  529.          this.gotoAndStop("fall");
  530.          _root.estado = 5;
  531.          return undefined;
  532.       }
  533.       if(slide)
  534.       {
  535.          this.gotoAndStop("slide");
  536.          _root.estado = 6;
  537.          return undefined;
  538.       }
  539.       if(shooting)
  540.       {
  541.          if(!horizontal)
  542.          {
  543.             this.gotoAndStop("attackST");
  544.             return undefined;
  545.          }
  546.          if(horizontal)
  547.          {
  548.             this.gotoAndStop("attackRU");
  549.             sprite.gotoAndPlay(frame);
  550.             _root.estado = 2;
  551.             return undefined;
  552.          }
  553.       }
  554.       else
  555.       {
  556.          if(!horizontal)
  557.          {
  558.             this.gotoAndStop("standing");
  559.             _root.estado = 0;
  560.             return undefined;
  561.          }
  562.          if(horizontal)
  563.          {
  564.             this.gotoAndStop("run");
  565.             _root.estado = 1;
  566.             return undefined;
  567.          }
  568.       }
  569.    }
  570.    pause = _root.pause;
  571.    if(!pause)
  572.    {
  573.       render();
  574.    }
  575.    frame = sprite._currentframe;
  576. }
  577.